home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Application.C < prev    next >
C/C++ Source or Header  |  1992-08-10  |  10KB  |  457 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Application.h"
  6.  
  7. #include "Document.h"
  8. #include "Class.h"
  9. #include "Storage.h"
  10. #include "FileDialog.h"
  11. #include "ObjectTable.h"
  12. #include "ClassManager.h"
  13. #include "ClipBoard.h"
  14. #include "ProgEnv.h"
  15. #include "Buttons.h"
  16. #include "StreamConnection.h"
  17. #include "WindowSystem.h"
  18. #include "Env.h"
  19. #include "ProgressDialog.h"
  20. #include "Data.h"
  21. #include "Alert_e.h"
  22. #include "Error.h"
  23. #include "Menu.h"
  24. #include "String.h"
  25. #include "Expander.h"
  26. #include "MenuBar.h"
  27. #include "DebuggerIF.h"
  28.  
  29. StreamConnection    *gRpc;
  30. Application         *gApplication;
  31. ClipBoard           *gClipBoard;
  32. int                 gArgc;
  33. char                **gArgv;
  34.  
  35. extern char *gProgPath;
  36.  
  37. //---- AppRpcConnection --------------------------------------------------------
  38.  
  39. class AppRpcConnection : public StreamConnection {
  40. public:
  41.     MetaDef(AppRpcConnection);
  42.     AppRpcConnection() : StreamConnection(-1)
  43.     { Open(gSystem->OpenConnection(SERVERNAME, SERVICENAME));
  44.       Talk(0, "enroll", gProgname); }
  45.     ~AppRpcConnection()
  46.     { SendTo(0, "remove", gProgname); }
  47.     void Dispatch(int from, char *req, char *buf, int len, char *&ret, int &retlen)
  48.     { gApplication->ExtCommand(from, req, buf, len, ret, retlen);
  49.       gWindowSystem->Update(); }
  50. };
  51.  
  52. NewMetaImpl0(AppRpcConnection,StreamConnection);
  53.  
  54. //---- ApplIntHandler ----------------------------------------------------------
  55.  
  56. class ApplIntHandler : public SysEvtHandler {
  57. public:
  58.     MetaDef(ApplIntHandler);
  59.     ApplIntHandler() : SysEvtHandler(eSigInterrupt)
  60.     { }
  61.     void Notify(SysEventCodes, int)
  62.     { if (gApplication) gApplication->Inspect(); }
  63. };
  64.  
  65. NewMetaImpl0(ApplIntHandler,SysEvtHandler);
  66.  
  67. //---- ApplErrorHandler --------------------------------------------------------
  68.  
  69. static void ApplErrorHandler(int level, bool, char *location, char *msg)
  70. {
  71.     gApplication->DoOnError(level, location, msg);
  72. } 
  73.  
  74. //---- Application -------------------------------------------------------------
  75.  
  76. NewAbstractMetaImpl(Application,Manager, (T(lastWindowPos), TS(version),
  77.     T(mainDocumentType), TP(fileDialog), TP(gApplication), TP(gClipBoard),
  78.     TVP(gArgv,gArgc), TP(gClassManager)));
  79.  
  80. FileDialog *Application::fileDialog;
  81.  
  82. Application::Application(int ac, char **av, Symbol &dt)
  83. {
  84.     if (gApplication)
  85.     Error("Application", "only one Application !!");
  86.  
  87.     gApplication= this;
  88.     version= "Version 3.0, 7/1/92, \251IFI & UBS-UBILAB";
  89.     gArgc= ac;
  90.     gArgv= av;
  91.     mainDocumentType= dt;
  92.  
  93.     ETInit(gArgv);
  94.     SetName(ProgramName());
  95.     WindowSystem::WSInit();
  96.     
  97.     SetErrorHandler(ApplErrorHandler);
  98.     lastWindowPos= Point(150, 100);
  99.     char *cp= Env::GetValue("Document.Position", (char*)0);
  100.     if (cp) {
  101.     IStream is(strlen(cp), cp);
  102.     is >> lastWindowPos;
  103.     }
  104. }
  105.  
  106. Application::~Application()
  107. {
  108.     if (gApplication == this)
  109.     gApplication= 0;
  110.  
  111.     SafeDelete(fileDialog);
  112. }
  113.  
  114. char *Application::GetName()
  115. {
  116.     return gProgname;
  117. }
  118.  
  119. FileDialog *Application::MakeFileDialog()
  120. {
  121.     return new FileDialog;
  122. }
  123.  
  124. void Application::NewManager(Symbol type)
  125. {
  126.     Manager *mp= DoMakeManager(type); // let user make his managers
  127.     if (mp) {
  128.     AddManager(mp);
  129.     mp->Show();
  130.     }
  131. }
  132.  
  133. void Application::ParseCommandLine(int argc, char **argv)
  134. {
  135.     for (int i= 1; i < argc;) {
  136.     if (argv[i][0] == '-') {
  137.         int n= DoParseOptions(argv[i], argv[i+1]);
  138.         if (n > 0)
  139.         i+= n;
  140.         else
  141.         i++;
  142.     } else 
  143.         OpenDocument(argv[i++]);
  144.     }
  145. }
  146.  
  147. int Application::DoParseOptions(char *arg0, char*)
  148. {
  149.     if (arg0[0] == '-' && arg0[1] == 'E') {
  150.     if (arg0[2] == 'e') 
  151.         gProgEnv->Start();
  152.     if (arg0[2] == 'h') 
  153.         gProgEnv->ShowInHierarchy(this->IsA());
  154.     return 1;
  155.     }
  156.     return 0;
  157. }
  158.  
  159. void Application::RemoveManager(Manager *mp)
  160. {
  161.     Manager::RemoveManager(mp);
  162.     if (Size() <= 0 && !IsOpen())
  163.     Quit();
  164. }
  165.  
  166. char *Application::ProgramName()
  167. {
  168.     return BaseName(gProgname);
  169. }
  170.  
  171. Point Application::GetInitialWindowPos()
  172. {
  173.     return GetNewDocumentPos();
  174. }
  175.  
  176. void Application::About()
  177. {
  178.     ShowAlert(eAlertSun, "%s %s", ProgramName(), version);
  179. }
  180.  
  181. Command *Application::DoMenuCommand(int cmd)
  182. {
  183.     switch(cmd) {
  184.     case cNEW:
  185.     NewManager(mainDocumentType);
  186.     break;
  187.     case cQUIT:
  188.     Quit();
  189.     break;
  190.     case cABOUT:
  191.     About();
  192.     break;
  193.     case cOPEN:
  194.     OpenDocument(0);
  195.     break;
  196.     default:
  197.     Manager::DoMenuCommand(cmd);
  198.     break;
  199.     }
  200.     return gNoChanges;
  201. }
  202.  
  203. void Application::DoSetupMenu(Menu *m)
  204. {
  205.     Manager::DoSetupMenu(m);
  206.     m->EnableItems(cOPEN, cNEW, cQUIT, cABOUT, 0);
  207. }
  208.  
  209. void Application::Control(int id, int part, void *val)
  210. {
  211.     SendDown(id, part, val);
  212. }
  213.  
  214. void Application::ExtCommand(int from, char *rq, char *args, int len,
  215.                             char *&ret, int &retlen)
  216. {
  217.     char req[100];
  218.     strcpy(req, rq);
  219.     
  220.     if (strcmp(req, "remove") == 0) {
  221.     gWindowSystem->ExtCommand(from, req, args, len, ret, retlen);
  222.     return;
  223.     }
  224.     
  225.     char *cp= strchr(req, ':');
  226.     if (cp) {
  227.     *cp++= 0;
  228.     if (strcmp(req, "clipboard") == 0)
  229.         gWindowSystem->ExtCommand(from, cp, args, len, ret, retlen);
  230.     
  231.     else if (strcmp(req, "document") == 0) {
  232.         Iter next(MakeIterator());
  233.         Manager *first= (Manager*)next();
  234.         if (first)
  235.         first->ExtCommand(from, cp, args, len, ret, retlen);
  236.     } else if (strcmp(req, "application") == 0) {
  237.         if (strcmp(cp, "quit") == 0)
  238.         Quit();
  239.         else if (strcmp(cp, "about") == 0)
  240.         About();
  241.         else if (strcmp(cp, "new") == 0)
  242.         NewManager(mainDocumentType);
  243.         else if (strcmp(cp, "open") == 0)
  244.         OpenDocument(args);
  245.         else if (strcmp(cp, "inspect") == 0)
  246.         Inspect();
  247.         ret= "ok";
  248.     }
  249.     }
  250. }
  251.  
  252. void Application::Quit()
  253. {
  254.     if (Close())
  255.     gSystem->ExitControl();
  256. }
  257.  
  258. Manager *Application::DoMakeManager(Symbol type)
  259. {
  260.     return DoMakeDocuments(type);
  261. }
  262.  
  263. bool Application::OpenDocument(char *name)
  264. {
  265.     bool rc= FALSE, dodelete= FALSE;
  266.     Data *data;
  267.     Manager *mp;
  268.  
  269.     if (name == 0) {
  270.     if (fileDialog == 0)
  271.         fileDialog= MakeFileDialog();
  272.     if (fileDialog->ShowInWindow(eFDRead, 0, this) != cIdOk)
  273.         return FALSE;
  274.     name= fileDialog->FileName();
  275.     data= fileDialog->GetData();
  276.     } else {
  277.     data= new FileData(name);
  278.     dodelete= TRUE;
  279.     }
  280.       
  281.     if (!CanOpen(data)) {
  282.     ShowAlert(eAlertNote, "cannot handle document @I%s@P (%s)\n",
  283.                     data->FullName(), data->Type().AsString());
  284.     } else {
  285.     mp= DoMakeManager(data->Type()); // let user make his managers
  286.     if (mp) {
  287.         AddManager(mp);
  288.         mp->Show();
  289.         ((Document*)mp)->LoadData(data, TRUE);
  290.         gWindowSystem->Update();
  291.         rc= TRUE;
  292.     }
  293.     }
  294.     if (dodelete)
  295.     delete data;
  296.     return rc;
  297. }
  298.  
  299. bool Application::CanOpen(Data *data)
  300. {
  301.     if (mainDocumentType == cDocTypeUndef || mainDocumentType == data->Type())
  302.     return TRUE;
  303.     if (mainDocumentType == cDocTypeAscii && data->IsAscii())
  304.     return TRUE;
  305.     return FALSE;
  306. }
  307.  
  308. void Application::MakeInitManager()
  309. {
  310.     if (Size() <= 0)
  311.     NewManager(mainDocumentType);
  312. }
  313.  
  314. int Application::Run()
  315. {
  316.     gRpc= new AppRpcConnection;
  317.     gClipBoard= new ClipBoard;
  318.     gProgress= new ProgressImpl;
  319.     gSystem->AddSignalHandler(new ApplIntHandler);
  320.     
  321.     ParseCommandLine(gArgc, gArgv);
  322.  
  323.     MakeInitManager();
  324.  
  325.     Open();
  326.  
  327.     gSystem->Control();
  328.     
  329.     SetErrorHandler(DefaultErrorHandler);
  330.  
  331.     SafeDelete(gClipBoard);
  332.     SafeDelete(gRpc);
  333.     SafeDelete(gProgress);
  334.     
  335.     return 0;
  336. }
  337.  
  338. void Application::DoOnError(int level, char *location, char *msg)
  339. {
  340.     static bool inError= FALSE;
  341.     
  342.     if (level < Env::GetValue("System.IgnoreLevel", cError) || inError)
  343.     return;
  344.     inError= TRUE;
  345.     
  346.     char *type= "Warning";
  347.     if (level >= cFatal)
  348.     type= "Fatal";
  349.     else if (level >= cSysError)
  350.     type= "SysError";
  351.     else if (level >= cError)
  352.     type= "Error";
  353.     
  354.     cerr.form("%s: %s in <%s>: %s\n", ProgramName(), type, location, msg);
  355.     if (level >= cError) {
  356.     int r= ShowAlert(eAlertError, "%s: %s\nin @B%s@B: %s", ProgramName(),
  357.                             type, location, msg);
  358.     switch (r) {
  359.     case cIdIgnore:
  360.         break;
  361.         
  362.     case cIdAbort:
  363.         gSystem->Abort();
  364.         
  365.     case cIdInspect:
  366.         DebuggerIF *dbg= new DebuggerIF;
  367.         dbg->Attach(gProgPath, gSystem->GetPid());
  368.         delete dbg;
  369.         //gSystem->Wait(15000);
  370.         //ShowAlert(eAlertError, "%s: Could not attach to debugger\n", ProgramName());
  371.         //Inspect();
  372.         break;
  373.     }
  374.     }
  375.     inError= FALSE;
  376. }
  377.  
  378. //---- obsolete ----------------------------------------------------------------
  379.  
  380. Document *Application::FindDocument(int id)
  381. {
  382.     return (Document*) Application::FindManager(id);
  383. }
  384.  
  385. Document *Application::DoMakeDocuments(Symbol)
  386. {
  387.     return 0;
  388. }
  389.  
  390. bool Application::CloseAllDocuments()
  391. {
  392.     return Close();
  393. }
  394.  
  395. void Application::AddDocument(Document *dp)
  396. {
  397.     AddManager(dp);
  398. }
  399.  
  400. void Application::RemoveDocument(Document *mp)
  401. {
  402.     RemoveManager(mp);
  403. }
  404.  
  405. void Application::NewDocument(Symbol)
  406. {
  407. }
  408.  
  409. Point Application::GetNewDocumentPos()
  410. {
  411.     Point p= lastWindowPos;
  412.     lastWindowPos+= Point(40, 30);
  413.     return p;
  414. }
  415.  
  416. //---- external calls of ET++PE ------------------------------------------------
  417.  
  418. extern "C" int ETPE_Enter(Object *op);
  419.  
  420. static int CallCount= 0;
  421.  
  422. int ETPE_Enter(Object *op)
  423. {
  424.     int level= CallCount++;
  425.     Port *p= GrGetPort();
  426.  
  427.     if (op == 0)
  428.     op= gApplication;
  429.     
  430.     if (!ObjectTable::PtrIsValid(op)) {
  431.     fprintf(stderr, "ET++PE: 0x%x is not an instance of Object\n", (int)op);
  432.     return 0;
  433.     }
  434.  
  435.     op->Inspect();
  436.  
  437.     //---- nested event-loop    
  438.     while (CallCount > level && !gQuitApp)
  439.     gSystem->InnerLoop();
  440.     
  441.     if (gQuitApp)
  442.     CallCount= 0;
  443.     
  444.     fprintf(stderr, "\nETPE: Exit\n");
  445.     
  446.     GrSetPort(p);
  447.     
  448.     return level;
  449. }
  450.  
  451. int gCallCount(int d)
  452. {
  453.     CallCount+= d;
  454.     return CallCount;
  455. }
  456.  
  457.